home *** CD-ROM | disk | FTP | other *** search
- Path: uunet!ogicse!zephyr.ens.tek.com!tekred!saab!billr
- From: billr@saab.CNA.TEK.COM (Bill Randle)
- Newsgroups: comp.sources.games
- Subject: v11i010: tinymud2 - user-extendible multi-user adventure (v1.5.4), Part06/10
- Message-ID: <6055@tekred.CNA.TEK.COM>
- Date: 30 Jul 90 16:45:48 GMT
- Sender: news@tekred.CNA.TEK.COM
- Lines: 1479
- Approved: billr@saab.CNA.TEK.COM
- Posted: Mon Jul 30 09:45:48 1990
-
- Submitted-by: James Aspnes <asp@cs.cmu.edu>
- Posting-number: Volume 11, Issue 10
- Archive-name: tinymud2/Part06
- Supersedes: tinymud: Volume 8, Issue 80-83
-
-
-
- #! /bin/sh
- # This is a shell archive. Remove anything before this line, then unpack
- # it by saving it into a file and typing "sh file". To overwrite existing
- # files, type "sh file -c". You can also feed this as standard input via
- # unshar, or by typing "sh <file", e.g.. If this archive is complete, you
- # will see the following message at the end:
- # "End of archive 6 (of 10)."
- # Contents: player.c set.c tiny.docs
- # Wrapped by billr@saab on Fri Jul 27 15:27:47 1990
- PATH=/bin:/usr/bin:/usr/ucb ; export PATH
- if test -f 'player.c' -a "${1}" != "-c" ; then
- echo shar: Will not clobber existing file \"'player.c'\"
- else
- echo shar: Extracting \"'player.c'\" \(1801 characters\)
- sed "s/^X//" >'player.c' <<'END_OF_FILE'
- X#include "copyright.h"
- X
- X#include "db.h"
- X#include "config.h"
- X#include "interface.h"
- X#include "externs.h"
- X
- X#ifndef PLAYER_LIST
- X/* don't use this, it's expensive */
- X/* maybe soon we'll put in a hash table */
- Xdbref lookup_player(const char *name)
- X{
- X dbref i;
- X
- X for(i = 0; i < db_top; i++) {
- X if(Typeof(i) == TYPE_PLAYER
- X && db[i].name && !string_compare(db[i].name, name)) return i;
- X }
- X return NOTHING;
- X}
- X#endif PLAYER_LIST
- X
- Xdbref connect_player(const char *name, const char *password)
- X{
- X dbref player;
- X
- X if((player = lookup_player(name)) == NOTHING) return NOTHING;
- X if(db[player].password
- X && *db[player].password
- X &&strcmp(db[player].password, password)) return NOTHING;
- X
- X return player;
- X}
- X
- Xdbref create_player(const char *name, const char *password)
- X{
- X dbref player;
- X
- X if(!ok_player_name(name) || !ok_password(password)) return NOTHING;
- X
- X /* else he doesn't already exist, create him */
- X player = new_object();
- X
- X /* initialize everything */
- X db[player].name = alloc_string(name);
- X db[player].location = PLAYER_START;
- X db[player].exits = PLAYER_START; /* home */
- X db[player].owner = player;
- X db[player].flags = TYPE_PLAYER;
- X db[player].password = alloc_string(password);
- X
- X /* link him to PLAYER_START */
- X PUSH(player, db[PLAYER_START].contents);
- X
- X#ifdef PLAYER_LIST
- X add_player(player);
- X#endif PLAYER_LIST
- X
- X return player;
- X}
- X
- Xvoid do_password(dbref player, const char *old, const char *newobj)
- X{
- X if(!db[player].password || strcmp(old, db[player].password)) {
- X notify(player, "Sorry");
- X } else if(!ok_password(newobj)) {
- X notify(player, "Bad new password.");
- X } else {
- X free((void *) db[player].password);
- X db[player].password = alloc_string(newobj);
- X notify(player, "Password changed.");
- X }
- X}
- END_OF_FILE
- if test 1801 -ne `wc -c <'player.c'`; then
- echo shar: \"'player.c'\" unpacked with wrong size!
- fi
- # end of 'player.c'
- fi
- if test -f 'set.c' -a "${1}" != "-c" ; then
- echo shar: Will not clobber existing file \"'set.c'\"
- else
- echo shar: Extracting \"'set.c'\" \(16561 characters\)
- sed "s/^X//" >'set.c' <<'END_OF_FILE'
- X#include "copyright.h"
- X
- X/* commands which set parameters */
- X#include <stdio.h>
- X#include <ctype.h>
- X
- X#include "db.h"
- X#include "config.h"
- X#include "match.h"
- X#include "interface.h"
- X#include "externs.h"
- X
- X#ifdef COMPRESS
- X#define alloc_compressed(x) alloc_string(compress(x))
- X#else /* COMPRESS */
- X#define alloc_compressed(x) alloc_string(x)
- X#endif /* COMPRESS */
- X
- X#define FREE_STRING(X) X = ((X) ? (free ((void *) (X)), NULL) : NULL)
- X
- Xstatic dbref match_controlled(dbref player, const char *name)
- X{
- X dbref match;
- X
- X init_match(player, name, NOTYPE);
- X match_everything();
- X
- X match = noisy_match_result();
- X if(match != NOTHING && !controls(player, match)) {
- X notify(player, "Permission denied.");
- X return NOTHING;
- X } else {
- X return match;
- X }
- X}
- X
- Xvoid do_name(dbref player, const char *name, char *newname)
- X{
- X dbref thing;
- X char *password;
- X
- X if((thing = match_controlled(player, name)) != NOTHING) {
- X /* check for bad name */
- X if(*newname == '\0') {
- X notify(player, "Give it what new name?");
- X return;
- X }
- X
- X /* check for renaming a player */
- X if(Typeof(thing) == TYPE_PLAYER) {
- X /* split off password */
- X for(password = newname;
- X *password && !isspace(*password);
- X password++);
- X /* eat whitespace */
- X if(*password) {
- X *password++ = '\0'; /* terminate name */
- X while(*password && isspace(*password)) password++;
- X }
- X
- X /* check for null password */
- X if(!*password) {
- X notify(player,
- X "You must specify a password to change a player name.");
- X notify(player, "E.g.: name player = newname password");
- X return;
- X } else if(strcmp (db[thing].name, "guest") == 0) {
- X notify(player,
- X "You are only a guest here...no name changing.");
- X return;
- X } else if(!db[thing].password) {
- X /* If original has no password, set one */
- X db[thing].password = alloc_string(password);
- X } else if(strcmp(password, db[thing].password)) {
- X notify(player, "Incorrect password.");
- X return;
- X } else if(string_compare(newname, db[thing].name) &&
- X !ok_player_name(newname)) {
- X notify(player, "You can't give a player that name.");
- X return;
- X }
- X /* everything ok, notify */
- X writelog("NAME CHANGE: %s(#%d) to %s\n",
- X db[thing].name, thing, newname);
- X#ifdef PLAYER_LIST
- X delete_player(thing);
- X free((void *) db[thing].name);
- X db[thing].name = alloc_string(newname);
- X add_player(thing);
- X notify(player, "Name set.");
- X return;
- X#endif PLAYER_LIST
- X } else {
- X if(!ok_name(newname)) {
- X notify(player, "That is not a reasonable name.");
- X return;
- X }
- X }
- X
- X /* everything ok, change the name */
- X if(db[thing].name) {
- X free((void *) db[thing].name);
- X }
- X db[thing].name = alloc_string(newname);
- X notify(player, "Name set.");
- X }
- X}
- X
- Xvoid do_describe(dbref player, const char *name, const char *description)
- X{
- X dbref thing;
- X
- X if((thing = match_controlled(player, name)) != NOTHING) {
- X if(db[thing].description) {
- X free((void *) db[thing].description);
- X }
- X db[thing].description = alloc_compressed(description);
- X notify(player, "Description set.");
- X }
- X}
- X
- Xvoid do_fail(dbref player, const char *name, const char *message)
- X{
- X dbref thing;
- X
- X if((thing = match_controlled(player, name)) != NOTHING) {
- X if(db[thing].fail_message) {
- X free((void *) db[thing].fail_message);
- X }
- X db[thing].fail_message = alloc_compressed(message);
- X notify(player, "Message set.");
- X }
- X}
- X
- Xvoid do_success(dbref player, const char *name, const char *message)
- X{
- X dbref thing;
- X
- X if((thing = match_controlled(player, name)) != NOTHING) {
- X if(db[thing].succ_message) {
- X free((void *) db[thing].succ_message);
- X }
- X db[thing].succ_message = alloc_compressed(message);
- X notify(player, "Message set.");
- X }
- X}
- X
- Xvoid do_osuccess(dbref player, const char *name, const char *message)
- X{
- X dbref thing;
- X
- X if((thing = match_controlled(player, name)) != NOTHING) {
- X if(db[thing].osuccess) {
- X free((void *) db[thing].osuccess);
- X }
- X db[thing].osuccess = alloc_compressed(message);
- X notify(player, "Message set.");
- X }
- X}
- X
- Xvoid do_ofail(dbref player, const char *name, const char *message)
- X{
- X dbref thing;
- X
- X if((thing = match_controlled(player, name)) != NOTHING) {
- X if(db[thing].ofail) {
- X free((void *) db[thing].ofail);
- X }
- X db[thing].ofail = alloc_compressed(message);
- X notify(player, "Message set.");
- X }
- X}
- X
- Xvoid do_lock(dbref player, const char *name, const char *keyname)
- X{
- X dbref thing;
- X struct boolexp *key;
- X
- X init_match(player, name, NOTYPE);
- X match_everything();
- X
- X switch(thing = match_result()) {
- X case NOTHING:
- X notify(player, "I don't see what you want to lock!");
- X return;
- X case AMBIGUOUS:
- X notify(player, "I don't know which one you want to lock!");
- X return;
- X default:
- X if(!controls(player, thing)) {
- X notify(player, "You can't lock that!");
- X return;
- X }
- X break;
- X }
- X
- X key = parse_boolexp(player, keyname);
- X if(key == TRUE_BOOLEXP) {
- X notify(player, "I don't understand that key.");
- X } else {
- X /* everything ok, do it */
- X free_boolexp(db[thing].key);
- X db[thing].key = key;
- X notify(player, "Locked.");
- X }
- X}
- X
- Xvoid do_unlock(dbref player, const char *name)
- X{
- X dbref thing;
- X
- X if((thing = match_controlled(player, name)) != NOTHING) {
- X free_boolexp(db[thing].key);
- X db[thing].key = TRUE_BOOLEXP;
- X notify(player, "Unlocked.");
- X }
- X}
- X
- Xvoid do_unlink(dbref player, const char *name)
- X{
- X dbref exit;
- X
- X init_match(player, name, TYPE_EXIT);
- X match_exit();
- X match_here();
- X if(Wizard(player)) {
- X match_absolute();
- X }
- X
- X switch(exit = match_result()) {
- X case NOTHING:
- X notify(player, "Unlink what?");
- X break;
- X case AMBIGUOUS:
- X notify(player, "I don't know which one you mean!");
- X break;
- X default:
- X if(!controls(player, exit)) {
- X notify(player, "Permission denied.");
- X } else {
- X switch(Typeof(exit)) {
- X case TYPE_EXIT:
- X db[exit].location = NOTHING;
- X notify(player, "Unlinked.");
- X break;
- X case TYPE_ROOM:
- X db[exit].location = NOTHING;
- X notify(player, "Dropto removed.");
- X break;
- X default:
- X notify(player, "You can't unlink that!");
- X break;
- X }
- X }
- X }
- X}
- X
- Xvoid do_chown(dbref player, const char *name, const char *newobj)
- X{
- X dbref thing;
- X dbref owner;
- X
- X init_match(player, name, NOTYPE);
- X match_everything();
- X
- X if((thing = noisy_match_result()) == NOTHING) {
- X return;
- X } else if((owner = lookup_player(newobj)) == NOTHING &&
- X string_compare(newobj,"me")) {
- X notify(player, "I couldn't find that player.");
- X } else if(Typeof(thing) == TYPE_PLAYER) {
- X notify(player, "Players always own themselves.");
- X } else if (!Wizard(player) &&
- X ((string_compare(newobj,"me") &&
- X owner != player) || !(db[thing].flags & UNWANTED))) {
- X notify(player, "Permission denied.");
- X } else if (!Wizard(player) && !could_doit(player,thing)) {
- X notify(player, "That item is locked.");
- X } else {
- X if (!string_compare(newobj,"me"))
- X owner = player;
- X db[thing].owner = owner;
- X notify(player, "Owner changed.");
- X }
- X}
- X
- Xvoid do_set(dbref player, const char *name, const char *flag)
- X{
- X dbref thing;
- X const char *p;
- X object_flag_type f;
- X
- X /* find thing */
- X if((thing = match_controlled(player, name)) == NOTHING) return;
- X
- X /* move p past NOT_TOKEN if present */
- X for(p = flag; *p && (*p == NOT_TOKEN || isspace(*p)); p++);
- X
- X /* identify flag */
- X if(*p == '\0') {
- X notify(player, "You must specify a flag to set.");
- X return;
- X } else if(string_prefix("LINK_OK", p)) {
- X f = LINK_OK;
- X } else if(string_prefix("DARK", p)) {
- X f = DARK;
- X } else if(string_prefix("STICKY", p)) {
- X f = STICKY;
- X } else if(string_prefix("WIZARD", p) ||
- X string_prefix("TINKER", p)) {
- X f = WIZARD;
- X } else if(string_prefix("TEMPLE", p) ||
- X string_prefix("JUNKPILE", p)) {
- X f = TEMPLE;
- X } else if(string_prefix("HAVEN", p)) {
- X f = HAVEN;
- X } else if(string_prefix("ABODE", p)) {
- X f = ABODE;
- X } else if(string_prefix("UNWANTED", p)) {
- X f = UNWANTED;
- X#ifdef ROBOT_MODE
- X } else if(string_prefix("ROBOT", p) ||
- X string_prefix("BOT", p)) {
- X if (Typeof(thing) == TYPE_PLAYER) {
- X if (Wizard(player)) {
- X writelog ("ROBOT: success %s(%d) %s %s(%d)\n",
- X db[player].name, player,
- X *flag == NOT_TOKEN ? "reset" : "set",
- X db[thing].name, thing);
- X } else {
- X writelog ("ROBOT: failed %s(%d) %s %s(%d)\n",
- X db[player].name, player,
- X *flag == NOT_TOKEN ? "reset" : "set",
- X db[thing].name, thing);
- X notify(player,
- X#ifndef TINKER
- X "Only a Wizard can designate a player robotic.");
- X#else TINKER
- X "Only a Tinker can designate a player robotic.");
- X#endif TINKER
- X return;
- X }
- X }
- X f = ROBOT;
- X#endif ROBOT_MODE
- X } else if(string_prefix("TABULAR_WHO", p)) {
- X f = TABULAR_WHO;
- X } else if(string_prefix("REVERSED_WHO", p)) {
- X f = REVERSED_WHO;
- X#ifdef GENDER
- X } else if(string_prefix("MALE", p) || string_prefix("FEMALE", p) ||
- X string_prefix("NEUTER", p) || string_prefix("UNASSIGNED", p)) {
- X if (Typeof(thing) != TYPE_PLAYER) {
- X notify(player, "Sorry, only players have gender.");
- X return;
- X }
- X if (thing != player && !Wizard(player)) {
- X notify(player, "You can only give yourself a sex-change.");
- X return;
- X }
- X db[thing].flags &= ~GENDER_MASK;
- X if(string_prefix("UNASSIGNED", p) || *flag == NOT_TOKEN) {
- X db[thing].flags |= (GENDER_UNASSIGNED << GENDER_SHIFT);
- X notify(player, "Gender set to unassigned.");
- X } else if (string_prefix("MALE", p)) {
- X db[thing].flags |= (GENDER_MALE << GENDER_SHIFT);
- X notify(player, "Gender set to male.");
- X } else if(string_prefix("FEMALE", p)) {
- X db[thing].flags |= (GENDER_FEMALE << GENDER_SHIFT);
- X notify(player, "Gender set to female.");
- X } else if(string_prefix("NEUTER", p)) {
- X db[thing].flags |= (GENDER_NEUTER << GENDER_SHIFT);
- X notify(player, "Gender set to neuter.");
- X }
- X return;
- X#endif /* GENDER */
- X#ifdef RESTRICTED_BUILDING
- X } else if(string_prefix("BUILDER", p) ||) {
- X string_prefix("CONSTRUCTOR", p)
- X f = BUILDER;
- X#endif /* RESTRICTED_BUILDING */
- X } else {
- X notify(player, "I don't recognize that flag.");
- X return;
- X }
- X
- X /* check for restricted flag */
- X if(!Wizard(player)
- X && (f == TEMPLE
- X#ifdef RESTRICTED_BUILDING
- X || f == BUILDER
- X#endif /* RESTRICTED_BUILDING */
- X || f == DARK &&
- X (Typeof(thing) != TYPE_ROOM && Typeof(thing) != TYPE_THING))) {
- X notify(player, "Permission denied.");
- X return;
- X }
- X
- X#ifdef GOD_PRIV
- X if (!God(player) && f == DARK && Typeof(thing) == TYPE_PLAYER) {
- X notify(player, "Permission denied.");
- X return;
- X }
- X#endif GOD_PRIV
- X
- X if (!Wizard(player) && f == DARK && Typeof(thing) == TYPE_THING &&
- X db[thing].location != player) {
- X notify(player, "You must be holding an object to set it DARK.");
- X return;
- X }
- X
- X#ifdef GOD_PRIV
- X if(!God(player) && (f == WIZARD)) {
- X#else
- X if (!Wizard(player) && (f == WIZARD)) {
- X#endif GOD_PRIV
- X writelog ("WIZARD: failed %s(%d) %s %s(%d)\n",
- X db[player].name, player,
- X *flag == NOT_TOKEN ? "reset" : "set",
- X db[thing].name, thing);
- X
- X notify(player, "Permission denied.");
- X return;
- X }
- X
- X if (f == WIZARD) {
- X writelog ("WIZARD: success %s(%d) %s %s(%d)\n",
- X db[player].name, player,
- X *flag == NOT_TOKEN ? "reset" : "set",
- X db[thing].name, thing);
- X }
- X
- X#ifdef GOD_PRIV
- X /* check for unGODding */
- X if (f == WIZARD && God(thing)) {
- X notify(player, "Gods can not me made mortal.");
- X return;
- X }
- X#else
- X if (f == WIZARD && thing == player) {
- X notify(player, "You cannot make yourself mortal!");
- X return;
- X }
- X#endif GOD_PRIV
- X
- X if ( f==HAVEN && !(Typeof(thing) == TYPE_ROOM ||
- X Typeof(thing) == TYPE_PLAYER)) {
- X notify(player, "Only rooms or players can be HAVEN.");
- X return;
- X }
- X
- X if (f==UNWANTED && Typeof(thing)==TYPE_PLAYER) {
- X notify(player, "You should always want yourself.");
- X return;
- X }
- X
- X if ((f==TABULAR_WHO || f==REVERSED_WHO) &&
- X Typeof(thing) != TYPE_PLAYER) {
- X notify(player, "Player preference flags can only be set on players.");
- X return;
- X }
- X
- X /* else everything is ok, do the set */
- X if(*flag == NOT_TOKEN) {
- X /* reset the flag */
- X db[thing].flags &= ~f;
- X notify(player, "Flag reset.");
- X } else {
- X /* set the flag */
- X db[thing].flags |= f;
- X notify(player, "Flag set.");
- X }
- X}
- X
- X#ifdef RECYCLE
- X/****************************************************************
- X * do_recycle: Allow any player to give an item away...the item
- X * is @chowned to the "Recycler" player, and if it's a thing,
- X * it is @linked to the home of the "Recycler" as well.
- X ****************************************************************/
- X
- Xvoid do_recycle(dbref player, const char *name)
- X{
- X dbref thing, recip, i;
- X char buf[BUFFER_LEN];
- X
- X if (!name || !*name) {
- X notify(player, "You must specify an object to @recycle.");
- X return;
- X }
- X
- X if((thing = match_controlled(player, name)) == NOTHING) return;
- X
- X if(Typeof(thing) == TYPE_PLAYER) {
- X notify(player, "You can't @recycle players.");
- X return;
- X }
- X
- X if((recip = lookup_player(RECYCLER)) == NOTHING) {
- X notify(player, "There is no current Recycler.");
- X return;
- X }
- X
- X /* Okay - do it */
- X db[thing].owner = recip;
- X
- X /* If its a thing, link it to the Recyclers home */
- X if (Typeof(thing) == TYPE_THING) {
- X db[thing].exits = db[recip].exits;
- X moveto (thing, db[thing].exits);
- X }
- X
- X /* Clear its strings */
- X FREE_STRING (db[thing].name);
- X FREE_STRING (db[thing].description);
- X FREE_STRING (db[thing].fail_message);
- X FREE_STRING (db[thing].ofail);
- X FREE_STRING (db[thing].succ_message);
- X FREE_STRING (db[thing].osuccess);
- X sprintf (buf, "junk-%d", thing);
- X db[thing].name = alloc_string(buf);
- X
- X /* unlock it */
- X free_boolexp(db[thing].key);
- X db[thing].key = TRUE_BOOLEXP;
- X
- X /* Make it worthless */
- X db[thing].pennies = 1;
- X
- X /* Make it up for grabs */
- X db[thing].flags |= UNWANTED;
- X
- X /* Tell player we did it */
- X notify(player, "Object recycled.");
- X}
- X
- X/****************************************************************
- X * do_count: count things...
- X * players: Number of objects owned, carried
- X * rooms: number of exits from & to, number contents
- X ****************************************************************/
- X
- Xvoid do_count(dbref player, const char *name)
- X{
- X dbref thing, i, exit;
- X char buf[BUFFER_LEN];
- X int owned=0, contents=0, from=0, to=0, objects=0, rooms=0, exits=0;
- X int rowned=0, rplayers=0, robjects=0, rrooms=0, rexits=0;
- X
- X if (!name || !*name) {
- X notify(player, "You must specify an object to @count.");
- X return;
- X }
- X
- X if((thing = match_controlled(player, name)) == NOTHING) return;
- X
- X if(Typeof(thing) != TYPE_PLAYER && Typeof(thing) != TYPE_ROOM) {
- X notify(player, "You can only @count people or rooms.\n");
- X return;
- X }
- X
- X if(!payfor(player, FIND_COST)) {
- X notify(player, "You don't have enough pennies.");
- X return;
- X }
- X
- X switch (Typeof(thing)) {
- X case TYPE_PLAYER:
- X for (i=0; i<db_top; i++) {
- X if (db[i].location == thing) contents++;
- X if (db[i].owner == thing) {
- X switch (Typeof(i)) {
- X case TYPE_THING: objects++; break;
- X case TYPE_EXIT: exits++; break;
- X case TYPE_ROOM: rooms++; break;
- X }
- X owned++;
- X }
- X }
- X sprintf(buf,
- X "%s owns %d objects (%d things, %d rooms, %d exits), %d carried.",
- X unparse_object(player, thing),
- X owned, objects, rooms, exits, contents);
- X notify(player, buf);
- X break;
- X
- X case TYPE_ROOM:
- X for (i=0; i<db_top; i++) {
- X if (db[i].location == thing) {
- X if (Typeof(i) == TYPE_EXIT) {
- X to++;
- X } else {
- X contents++;
- X }
- X }
- X }
- X DOLIST(exit, db[thing].exits) {
- X from++;
- X }
- X sprintf(buf, "%s has %d entrances, %d exits, %d objects.",
- X unparse_object(player, thing), to, from, contents);
- X notify(player, buf);
- X
- X if (!Wizard (player)) break;
- X
- X for (i=0; i<db_top; i++) {
- X if (db[db[i].owner].location == thing) {
- X switch (Typeof(i)) {
- X case TYPE_EXIT: rexits++; break;
- X case TYPE_ROOM: rrooms++; break;
- X case TYPE_THING: robjects++; break;
- X case TYPE_PLAYER: rplayers++; break;
- X }
- X rowned++;
- X }
- X }
- X
- X if (rplayers == 0) {
- X sprintf (buf, "There are no players in %s.\n",
- X unparse_object (player, thing));
- X } else {
- X sprintf(buf,
- X "The %d player%s in %s own%s %d %s: %d %s, %d %s, %d %s\n.",
- X rplayers, (rplayers == 1) ? "" : "s",
- X unparse_object(player, thing), (rplayers == 1) ? "s" : "",
- X rowned, "objects", robjects, "things", rrooms, "rooms",
- X rexits, "exits");
- X }
- X
- X notify(player, buf);
- X
- X break;
- X }
- X
- X}
- X#endif RECYCLE
- X
- END_OF_FILE
- if test 16561 -ne `wc -c <'set.c'`; then
- echo shar: \"'set.c'\" unpacked with wrong size!
- fi
- # end of 'set.c'
- fi
- if test -f 'tiny.docs' -a "${1}" != "-c" ; then
- echo shar: Will not clobber existing file \"'tiny.docs'\"
- else
- echo shar: Extracting \"'tiny.docs'\" \(33769 characters\)
- sed "s/^X//" >'tiny.docs' <<'END_OF_FILE'
- XThis set of docs is tailored for Chaos, which is running TinyMUCK2.1.1.
- XGenerally, though, these commands hold true for any mud.
- X
- XCOMMANDS: drop, examine, get, give, go, gripe, help, inventory, kill, look,
- Xnews, OUPUTPREFIX, OUTPUTSUFFIX, page, QUIT, rob, say, score, whisper, WHO,
- X@action, @attach, @boot, @chown, @create, @describe, @dump, @dig, @drop, @dump,
- X@fail, @find, @force, @link, @lock, @name, @newpassword, @odrop, @ofail, @open,
- X@osuccess, @password, @pcreate, @prog, @recycle, @set, @shutdown, @stats,
- X@success, @teleport, @toad, @unlink, @unlock, @wall
- X
- XTOPICS: being killed, custom commands, control, costs, dropping, drop-tos,
- Xfailure, flags (wizard, sticky, link_ok, dark, temple, haven, chown_ok,
- Xabode, jump_ok, mucker, builder), gender, goal, here, homes, me, money,
- Xrobbery, sacrificing, strings, substitutions, success, types, actions,
- Xlinking, meta-links, properties, muf.
- X
- Xdrop <object>. Drops the <object> if you are holding it. It moves the object
- X to the room you are in, unless its STICKY flag is set (See
- X STICKY), or the room has a drop-to (See DROP-TOS).
- X Dropping a thing in a room with the TEMPLE flag set
- X sacrifices it (See SACRIFICING). Unlinked exits can only
- X be dropped in rooms you control (See CONTROL).
- X 'throw' is the same as 'drop'.
- X
- Xexamine [object]. Displays all available information about <object>. <object>
- X can be specified as <name> or #<number>, or as 'me' or 'here'.
- X You must control (See CONTROL) the object to examine it. If
- X you do not control the object, you will just be shown the
- X owner of the object and its description.
- X Wizards can examine objects in other rooms using #<number>
- X or *<player>.
- X
- Xget <object>. Picks up <object> if it is in the same room as you, and if
- X it is not locked (See @lock). <object> can be a thing or an
- X unlinked exit.
- X 'take' is the same as 'get'.
- X
- Xgive <player>=<pennies>. Gives <player> the specified number of pennies. The
- X only thing you can give is pennies. You can't give someone
- X pennies if their new total would be greater than 10000.
- X Wizards can give as many pennies as they wish, even negative
- X amounts, without affecting their own supply, and can give
- X pennies to things to change their sacrifice values.
- X
- Xgo[to] <direction>; go[to] home.
- X Goes in the specified direction. 'go home' is a special
- X command that returns you to your home (See HOMES). The word
- X 'go' may be omitted. (You can 'go east', or simply 'east').
- X 'move' is the same as 'go'.
- X
- Xgripe <message>. Sends <message> to the system maintainer.
- X
- Xhelp. This displays a short help message.
- X
- Xinventory. Lists what you are carrying. This can usually be abbreviated
- X to inv.
- X
- Xkill <player> [=<cost>]. Attempts to kill <player>. Killing costs either
- X <cost> or 10 pennies, whichever is greater. The probability
- X of success is <cost> percent. Spending 100 pennies always
- X works (except against Wizards, who can never be killed).
- X Killing a player sends them to their home (See HOMES), just
- X as the command 'go home' would (See go). It also gives the
- X killed player 50 pennies.
- X Players cannot be killed in rooms which have the HAVEN flag
- X set (see HAVEN).
- X
- Xlook [object]. Displays the description of <object>, or the room you're in
- X if you don't specify one. <object> can be a thing, player,
- X exit, or room, specified as <name> or #<number> or 'me' or
- X 'here'. Wizards can look at objects in other rooms using
- X #<number> or *<player>.
- X 'read' is the same as 'look'.
- X
- Xnews. Displays the current news file for the game. Must be typed
- X in full.
- X
- XOUTPUTPREFIX [string]. Must be in all capitals, and must be typed in full.
- X This prints the given string before the output of every
- X command.
- X
- XOUTPUTSUFFIX [string]. Must be in all capitals, and must be typed in full.
- X This prints the given string after the output of every
- X command.
- X
- Xpage <player> [=<message>]. This tells a player that you are looking for them.
- X They will get a message telling them your name and location.
- X This costs 1 penny. If you include the '=<message>', it will
- X tell the player your name and your message, along with your
- X location. This will not work if the player you're trying to
- X page is not connected. If a player has the HAVEN flag set
- X (See HAVEN), you cannot page them, and they will not be
- X notified that you tried.
- X
- Xpose <action>. The normal abbreviation for this is ':<message>'. This is used
- X for actions, ex. if your name was Igor, and you typed ':falls
- X down.', everyone would see "Igor falls down." (See also
- X whisper).
- X
- XQUIT. This command logs you out of the game. Must be in all capitals.
- X
- Xrob <player>. Attempts to steal one penny from <player>. The only thing
- X you can rob are pennies. Being robbed can be prevented (See
- X ROBBING).
- X
- Xsay <message>. Says <message> out loud. You can also use '"<message>'.
- X
- Xscore. Displays how many pennies you are carrying.
- X
- Xwhisper <player>=<message>. Whispers <message> to <player>, if they are in
- X the same room as you. No one else can see the message.
- X Wizards can whisper *<player>=<message> to whisper to
- X players in other rooms. This command will not work if
- X the player you are trying to whisper to is not connected.
- X
- XWHO [<player>]. List the name of every player currently logged in, and how
- X long they have been inactive. If given a player name, it
- X displays only that name and idle time. Must be in all
- X capitals.
- X
- X@action <name>[=<object>]. This sets up an action and attaches it to the
- X thing, room, or player specified. '@action' alone
- X will create an action and you can then use '@attach' to
- X attach it to something (See @attach, ACTIONS).
- X
- X@attach <name>=<object>. Attaches the named action to <object>.
- X
- X@boot <player>. Disconnects the player from the game. Only Wizards can use
- X this command.
- X
- X@chown <object>[=<player>]. Changes the ownership of <object> to <player>.
- X Normally, only wizards may use this command. However,
- X if the object is set CHOWN_OK (see CHOWN_OK), players
- X can chown it to themselves with 'chown <object>' if they
- X pick the object up. Players can't be @chowned; they always
- X own themselves.
- X
- X@create <name> [=<cost>]. Creates a thing with the specified name. Creation
- X costs either <cost> pennies or 10 pennies, whichever is
- X greater. The value of a thing is proportional to its cost.
- X To be exact, value=(cost/5)-1.
- X
- X@describe <object> [=<description>]. <object> can be a thing, player, exit, or
- X room, specified as <name> or #<number> or 'me' or 'here'.
- X This sets the description a player sees when they use the
- X command 'look <object>'. Without a description argument, it
- X clears the message.
- X It can be abbreviated @desc.
- X
- X@dig <name>. Creates a new room with the specified name and displays its
- X number. This costs 10 pennies.
- X
- X@drop <object>[=<message>]. Sets the drop message on <object>. <object>
- X can be specified as <name> or #<number> or 'me' or 'here'.
- X The drop message on a thing is displayed when the
- X thing is dropped. The drop message on an exit is displayed
- X when the player first enters the destination room. The drop
- X message on a player tells whoever killed them how they died.
- X Without a message argument, it clears the message. (See
- X @odrop).
- X
- X@dump. Only Wizards may use this command. Saves the database from
- X memory to disk. Automatically occurs every hour, and when
- X @shutdown is used.
- X
- X@fail <object> [=<message>]. <object> can be a thing, player, exit, or room,
- X specified as <name> or #<number> or 'me' or 'here'. Sets the
- X fail message for <object>. The message is displayed when a
- X player fails to use <object> (See FAILURE). Without a
- X message argument, it clears the message. (See @ofail).
- X
- X@find [name]. Displays the name and number of every room, thing, or player
- X that you control whose name matches <name>. Because the
- X command is computationally expensive, this costs 1 penny
- X or more, depending on the MUD.
- X
- X@force <player>=<command>. Only Wizards may use this command. Forces <player>
- X to do <command>.
- X
- X@link <object>=<number>; @link <object>=here; @link <dir>|<room>=home. Links
- X <object> to room specified by <number>. For things and
- X players, it sets their home room (See HOMES). For rooms, it
- X sets the drop-to room (See DROP-TOS). To link to a room,
- X you must control it, or it must be set LINK_OK (for exits),
- X or ABODE (for things, players, and rooms). (See LINK_OK and
- X ABODE). Linking costs 1 penny. If someone else owned the
- X exit, their penny is reimbursed. You can link exits to any
- X object, if you own it or it is set LINK_OK. (See LINKING,
- X HOMES, DROP-TOS).
- X Wizards can @link objects in other rooms using #<number>
- X or *<player>.
- X
- X@lock <object>=<key>. Locks <object> to a specific key(s). <object> can be
- X specified as <name> or #<number>, or as 'me' or 'here'.
- X Boolean expressions are allowed, using '&' (and), '|' (or),
- X '!' (not), and parentheses ('(' and ')') for grouping. To
- X lock to a player, prefix their name with '*' (ex. '*Igor').
- X You can lock to a program, in the same manner as locking to
- X an object (by name or number). You can also lock to a property,
- X with '@lock <exit>=<property>:<type>'. For example, to lock
- X a door to anyone that is male, you '@lock <exit>=sex:male'.
- X Notice that this will allow anyone carrying a male object to
- X pass the exit as well.
- X
- X@name <object>=<new name> [<password>]. Changes the name of <object>. <object>
- X can be a thing, player, exit, or room, specified as <name>
- X or #<number> or 'me' or 'here'. For a player, it requires
- X the player's password.
- X
- X@newpassword <player>=<password>. Only Wizards may use this command. Changes
- X <player>'s password, informing <player> that you changed it.
- X Must be typed in full.
- X
- X@odrop <object>[=<message>]. Sets the odrop message on <object>. <object>
- X can be specified as <name> or #<number> or 'me' or 'here'.
- X The odrop message on a thing is displayed to everyone
- X else in the room whenthe thing is dropped. The odrop message
- X on an exit is displayed to everyone else in the room when the
- X player first enters the destination room. The odrop message
- X on a player tells everyone else how they died if they are
- X killed. Without a message argument, it clears the message.
- X (See @drop).
- X
- X@ofail <object>[=<message>]. Sets the ofail message on <object>. <object>
- X can be specified as <name> or #<number>, or as 'me' or 'here'.
- X The ofail message, prefixed by the player's name, is shown
- X to others when the player fails to use <object>. Without a
- X message argument, it clears the message.
- X (See @fail, FAILURE).
- X
- X@open <dir>[;<other dir>]* [=<number>]. Creates an exit in the specified
- X direction(s). If <number> is specified, it is linked to that
- X room. Otherwise, it is created unlinked. You or anyone else
- X may use the '@link' command to specify where the unlinked
- X exit leads. Opening an exit costs 1 penny. If you specify
- X <number>, linking costs 1 more penny.
- X
- X@osuccess <object>[=<message>]. Sets the osuccess message on <object>.
- X <object> can be specified as <name> or #<number>, or as
- X 'me' or 'here'. The osuccess message, prefixed by the
- X player's name, is shown to others when the player
- X successfully uses <object>. Without a message argument, it
- X clears the message. It can be abbreviated @osucc.
- X (See @success, SUCCESS).
- X
- X@password <old password>=<new password>. This changes your password.
- X
- X@pcreate <name>. On muds with registration, this is a Wizard-only command
- X that creates a character with the given name.
- X
- X@prog. See the MUF programmer's manual.
- X
- X@recycle <object>. This recycles the <object>. <object> can be a thing,
- X room, or exit, but not a player. It changes the object
- X to a garbage object, and its number and space are reused
- X later.
- X
- X@set <object>=<flag>; @set <object>=!<flag>. Sets (or, with '!', unsets) <flag>
- X on <object>. @set can also be used to set properties,
- X with '@set <object>=<property>:[type]' or '@set <object>=:' to
- X unset all properties. (See FLAGS, PROPERTIES).
- X
- X@shutdown. Only Wizards may use this command. Shuts down the game. Must
- X be typed in full.
- X
- X@stats [player]. Display the number of objects in the game. For Wizards, also
- X lists a breakdown by object types. Wizards can supply a player
- X name to count only objects owned by that player.
- X
- X@success <object> [=<message>]. Sets the success message for <object>.
- X <object> can be specified as <name> or #<number>, or as 'me'
- X or 'here'. The success message is displayed when a player
- X successfully uses <object>. Without a message argument,
- X it clears the message. It can be abbreviated @succ.
- X (See @osuccess, USING OBJECTS).
- X
- X@teleport [<object>=] <room>. Teleports <object> to <room>. <object> must be a
- X thing. (Wizards can also teleport players.) You must be able
- X to link to the destination, and either control (See CONTROL)
- X the object or its current location. You can only teleport
- X objects into a room, not into someone's inventory, unless you
- X are a Wizard. If the destination room has a drop-to, <object>
- X will go to the drop-to room instead.
- X
- X@toad <player>. Only Wizards may use this command. Turns the player into a
- X slimy toad, destroying their character. Must be typed in full.
- X
- X@unlink <dir>; @unlink here. Removes the link on the exit in the specified
- X direction, or removes the drop-to on the room. Unlinked exits
- X may be picked up and dropped elsewhere. Be careful, anyone
- X can relink an unlinked exit, becoming its new owner (but you
- X will be reimbursed your 1 penny). (See @link).
- X
- X@unlock <object>. Removes the lock on <object>. (See @lock).
- X
- X@wall <message>. Only Wizards may use this command. Shouts something to every
- X player connected. Must be typed in full.
- X
- XBEING KILLED:
- XGetting killed is no big deal. If you are killed, you return to your home, and
- Xall things you carry return to their homes. You also collect 50 pennies in
- Xinsurance money (unless you have >= 10000 pennies). See MONEY.
- X
- XCUSTOM COMMANDS:
- XCustom commands can be made one of two ways. You can either use exits, or use
- Xprograms.
- XUsing an exit: For example, to make a 'sit' command, one could "@open sit",
- Xthen "@link sit=here" (because unlinked exits can be stolen),
- X"@lock sit=me&!me" (impossible to be both at once, therefore always fails),
- Xand "@fail sit=You sit on the chair."; "@ofail sit=sits on the chair.".
- XSince nobody can go through it, it always fails. The @fail message is displayed
- Xto the player, and the @ofail message (preceded by the player's name) to
- Xeveryone else.
- XUsing a program: you'd create a MUF program on an appropriate object, like
- Xa 'sit' program on a chair. (See MUF).
- X
- XCONTROL:
- XThere are 3 rules to controlling objects: 1) You control anything you own. 2) A
- Xwizard controls everything. 3) Anybody controls an unlinked exit, even if it is
- Xlocked. Builders should beware of 3, lest their exits be linked or stolen.
- X(In other words, never leave unlinked exits lying around unless you *want*
- Xsomeone to get them).
- X
- XCOSTS:
- Xkill: 10p (or more, up to 100p).
- Xpage: 1p.
- X@create: 10p (or more, up to 505p), sacrifice value=(cost/5)-1.
- X@dig: 10p.
- X@find: 1p (or more, depending on the MUD).
- X@link: 1p (if you didn't already own it, +1p to the previous owner).
- X@open: 1p (2p if linked at the same time).
- X
- XDROPPING:
- XYou see the drop and odrop message on a thing when you drop it. You see
- Xthe drop and odrop messages on an exit when you go through it. You see the
- Xdrop and odrop messages on a person when you kill them. Drop and odrop
- Xmessages have no meaning for rooms.
- X
- XDROP-TOs:
- XWhen the @link command is used on a room, it sets a drop-to location. Any
- Xobject dropped in the room (if it isn't STICKY) will go to that location. If
- Xthe room is STICKY, the drop-to will be delayed until the last person in the
- Xroom has left.
- X
- XFAILURE:
- XYou fail to use a thing when you cannot take it (because its lock fails). You
- Xfail to use an exit when you cannot go through it (because it's unlinked or
- Xlocked). You fail to use a person when you fail to rob them. You fail to use a
- Xroom when you fail to look around (because it's locked).
- X
- XFLAGS:
- XThe flags are displayed as letters following an object's ID number. Flags are
- Xset with the @set command. The general flags are: W(izard), S(ticky),
- XL(ink_OK), D(ark), T(emple), H(aven), C(hown_OK), A(bode), J(ump_OK),
- XM(ucker), and B(uilder).
- XSee individual flag names.
- X
- XWIZARD:
- XIf a person is WIZARD, they are unkillable, subject to fewer restrictions,
- Xand able to use wizard commands. It is only meaningful for players. Only
- Xwizard #1 can set and unset this flag. In general, WIZARDs can do anything
- Xusing #<number> or *<player>. No Wizard can turn their own WIZARD flag off.
- X
- XSTICKY:
- XIf a thing is STICKY, it goes home when dropped (See HOMES). If a room is
- XSTICKY, its drop-to is delayed until the last person leaves (See DROP-TOS).
- XIf an action/exit is STICKY, and it is attached to an object, the object
- Xstays there when the action/exit is triggered. (See LINKING).
- XNot meaningful for players.
- X
- XLINK_OK:
- XIf something is LINK_OK, anyone can link actions or exits to it (but still
- Xnot from it). (See @link, LINKING).
- X
- XDARK:
- XIf a room is DARK, then when people besides the owner 'look' there, they only
- Xsee things they own. If a thing or player is DARK, then "look" does not list
- Xthat object in the room's Contents:. Only wizards can set players dark.
- X
- XTEMPLE:
- XIf a room is TEMPLE, you can sacrifice things for pennies by dropping them
- Xthere. It has no meaning for players, things, or exits. Only wizards can set
- Xthis flag.
- X
- XCHOWN_OK:
- XIf a thing is set CHOWN_OK, anyone can chown the object to themselves with
- X"@chown <thing>". They must pick up the object to do this.
- X
- XGENDER:
- X@set me=sex:male|female|neuter. Default unassigned. If a player's gender
- Xis set, %-substitutions will use the appropriate pronoun for that player. Only
- Xmeaningful for players. See SUBSTITUTIONS.
- X
- XHAVEN:
- X@set here=haven;@set me=haven. If a room is HAVEN, you cannot kill in that
- Xroom. If a player is set HAVEN, he cannot be paged.
- X
- XABODE:
- X@set here=abode. If a room is set ABODE, players can set their homes there,
- Xand can set the homes of objects there. (LINK_OK is now used only for exits,
- Xand ABODE is for players and objects.)
- X
- XJUMP_OK:
- X@set <object>=jump_ok. If a room is set JUMP_OK, programs can move people
- Xinto it. If a player is set JUMP_OK, actions/exits linked to that player
- Xwill work (otherwise, they'll fail.) There are several other rules dealing
- Xwith JUMP_OK, but they all refer to restrictions on MUF programs. See the
- XMUF documentation for more details.
- X
- XBUILDER:
- XIf this flag is in effect, only people who are set BUILDER can create
- Xthings. Only Wizards can set this flag. (This flag is not currently in use
- Xon _Chaos_).
- X
- XMUCKER:
- XThis can only be set by Wizards. This flag allows players to enter @prog
- Xmode, and program in MUF. (See MUF).
- X
- XGOAL:
- XThere isn't one, except to have fun. If you're not having fun, quit. Have fun.
- X
- XHERE:
- XThe word 'here' refers to the room you are in. For example, to rename the room
- Xyou're in (if you control it), you could enter "@name here=<new name>".
- X
- XHOMES:
- XEvery thing or player has a home. This is where things go when sacrificed,
- Xplayers when they go home, or things with the STICKY flag set go when dropped
- X(See STICKY). Homes are set with the @link command. A thing's home defaults to
- Xthe room where it was created, if you control that room, or your home. You can
- Xlink an exit to send players home (with their inventory) by "@link <dir>=home".
- XDrop-tos can also be set to 'home' (See DROP-TOS, @link).
- X
- XME:
- XThe word 'me' refers to yourself. Some things to do when starting out: 1) give
- Xyourself a description with "@describe me=<description>", then look at yourself
- Xwith "look me". 2) prevent anyone else from robbing you with "@lock me=me". 3)
- Xset your gender, if you wish it known, with "@set me=sex:male" or
- X"@set me=sex:female" (or "@set me=sex:neuter" to be an 'it').
- X
- XMONEY:
- XBuilding and some other actions cost money. How to get money: 1) find pennies.
- X2) sacrifice (drop) things in the temple. 3) get killed. 4) be given money. 5)
- Xrob someone. Once you reach 10000 pennies, it becomes difficult to acquire
- Xmore. (See COSTS and SACRIFICING).
- XWizards don't need money to do anything.
- X
- XROBBERY:
- XWhen you rob someone, you succeed or fail to use them (See SUCCESS and
- XFAILURE). You can protect yourself from being robbed by entering "@lock me=me"
- X(See ME, and, @lock). If you lock yourself to yourself, you
- Xcan rob yourself and set off your @success and @osuccess messages. Try
- Xentering "@osucc me=is goofy." and robbing yourself in a crowd. (See rob).
- X
- XSACRIFICING:
- XYou sacrifice a thing by dropping it in the temple. Sacrificing an object
- Xgives you the value of an object. You can't sacrifice something you own.
- XIf you have >= 10000 pennies, all sacrifices are worth only 1 penny. The
- Xsacrifice value of a thing is set at creation by "@create frob=cost", by
- Xthe formula value=(cost/5)-1. Only a wizard can change the value of an
- Xobject, once created.
- X
- XSTRINGS:
- XObjects have 8 strings: 1) a name. 2) a description. 3) a success message
- X(seen by the player). 4) a fail message (seen by the player). 5) an
- Xosuccess message (seen by others). 6) an ofail message (seen by others).
- X7) a drop message (seen by the player). 8) a odrop message (seen by others).
- X
- XSUBSTITUTIONS:
- X@osuccess and @ofail messages may contain %-substitutions, which evaluate to
- Xgender-specific pronouns if the player's gender is set. They are: %s
- X(subjective) = Name, he, she, it. %o (objective) = Name, him, her, it. %p
- X(possessive) = Name's, his, her, its. %n (player's name) = Name. If you need a
- X'%', use %%. Ex. '@ofail teapot=burns %p hand on the hot teapot.' (See GENDER).
- XYou can also custom set your own substitutions. For example, '@set me=%o:hir',
- Xwill cause 'hir' to be substituted for %o instead of him, her, or it.
- X
- XSUCCESS:
- XYou successfully use an object when you take it. You use an exit successfully
- Xwhen you go through it. You successfully use a person successfully when you
- Xsuccessfully rob them. You successfully use a room when you look around.
- X
- XTYPES:
- XThere are 4 types of objects: things, players, exits, and rooms. The first
- Xletter following an object's ID number indicates the type: P(layer), E(xit),
- XR(oom), otherwise, thing. Things are inanimate objects that can be carried.
- XPlayers are animate objects that can move and carry. Exits are the means by
- Xwhich objects move. Rooms are locations that contain objects and linked
- Xexits. (Mind you, MUF programming can write its own rules. You can have
- Xmobile rooms (vehicles) and containers easily.)
- X
- XACTIONS:
- XActions are similar to exits, as you can '@link' them to things, and they can
- Xthen take you places, or bring things to you. Actions can thus be thought of
- Xas moveable exits, as they move with the thing or player that they are attached
- Xto. Actions will always work in the owner's rooms and in rooms with the JUMP_OK
- Xflag (See JUMP_OK) set. Actions attached to a thing always work whenever the
- Xthing is in the room. Actions attached to a player can only work for the player
- Xthat owns them.
- X
- XLINKING:
- X You can link to something if you control it, or if it is set LINK_OK (or
- XABODE). Being able to link means you can set the homes of objects or yourself
- Xto a room if it is set ABODE, and can set the destination of exits to a room
- Xif it is LINK_OK. (See LINK_OK and ABODE, and @link).
- X Linking an action/exit to an object means that a successful activation of the
- Xexit will bring the object to you, if the action/exit is attached to you or to
- Xthe room you're in. If that object is with another player, then it disappears
- Xfrom their inventory and is brought to you (either to your inventory, if the
- Xaction/exit is attached to you, or to your room, if it is attached to the
- Xroom). If the action/exit is attached to a thing, that thing will go home
- Xwhen the action/exit is triggered, unless the action/exit's STICKY flag is
- Xset (See STICKY). In that case, it summons the thing it's linked to as normal.
- XFor example: a sticky exit 'press button' attached to a 'candy machine', linked
- Xto a 'candy bar', summons the candy bar into the room. a 'eat candy' exit
- Xattached to the 'candy bar', linked to a 'half-eaten candy bar', will summon
- Xthe 'half-eaten candy bar' and remove the 'candy bar'.
- X Linking an action/exit to a player means that a successful activation of the
- Xexit will bring you to the player, if the player has their JUMP_OK flag set.
- X Linking an action/exit to a program allows you to use that program. (without
- Xcarrying it around with you).
- X Linking an action/exit to other actions/exits is a meta-link. (See META-LINKS).
- X
- XMETA-LINKS:
- XWhen a meta-link is triggered, all the exits that it was linked to will be
- Xtriggered at the same time. As a result, all of those exits will occur, moving
- Xobjects around or many other things. It will not move players to rooms however.
- XFor example, if action/exit 'a' is linked to thing #123, when 'a' is
- Xtriggered, it summons thing #123. If 'b' is linked to thing #456, when 'b'
- Xis triggered, it summons thing #456. If 'c' is linked to both 'a' and 'b',
- X(with "@link c=a;b"), when 'c' is triggered, *both* 'a' and 'b' will be
- Xtriggered, summoning #123 and #456 at the same time.
- X
- XPROPERTIES:
- XProperty lists (p-lists) are an extension to flags. Each object will have a
- Xp-list that can be checked against in locks and such. p-lists can be anything.
- XTo unset properties use "@set thing=property:". To remove all properties use
- X"@set thing=:".
- X
- XMUF:
- XMUF is a FORTH-derived language, in which programs can be written by players
- Xwith the MUCKER flag. Type 'man' to see a terse summary of MUF commands,
- Xor you can ftp the docs from belch.berkeley.edu, in the directory pub/tinymuck.
- X
- XExamples
- X--------
- X
- XIgor is a new player. He sets his description by typing:
- X @desc me=Igor is a ferret with an evil glint in his eye.
- XHe has guarded himself from being robbed, and set some fail messages on
- Xhimself that people will see when they try to rob him. He typed:
- X @lock me=me
- X @fail me=Igor chomps you on the knee with his little sharp teeth.
- X @ofail me=howls in pain as Igor bites them.
- XNow, here is what happens if Murf tries to rob Igor:
- X Murf types: rob igor
- X Murf sees: Igor chomps you on the knee with his little sharp teeth.
- X all else see: Murf howls in pain as Igor bites them.
- X'them' as a pronoun isn't to specific, and so Igor should do this:
- X @ofail me=howls in pain as Igor bites %o.
- XSo if Murf robs Igor, this is what everyone else will see:
- X Murf howls in pain as Igor bites him.
- XThis is assuming that Murf did a '@set me=sex:male'. If not, it would have
- Xprinted:
- X Murf howls in pain as Igor bites Murf.
- X
- XIgor wants to set a message that he will use a lot, so he sets his @osucc:
- X @osucc me=runs around the room nipping at everyone's heels.
- XNow, if he wants to display that message:
- X Igor types: rob me
- X Igor sees: You stole a penny.
- X Igor stole one of your pennies!
- X all else see: Igor runs around the room nipping at everyone's heels.
- X
- XIgor wants to make an object called 'Ferret chow'. He types:
- X @create Ferret Chow
- X @desc Ferret Chow=This is a big bag full of yummy ferret chow.
- X @succ Ferret Chow=You tear into the end of the bag, stuffing yourself.
- X @osucc Ferret Chow=tears into the Ferret Chow bag, eating greedily.
- XNow Igor decides that he wants to be the only one who can pick up the bag.
- X @lock Ferret Chow=me
- X @fail Ferret Chow=It's icky Ferret Chow. It would probably taste gross.
- X @ofail Ferret Chow=decides Ferret Chow is icky.
- XIf Igor picks up the bag:
- X Igor types: get Ferret Chow
- X Igor sees: You tear into the end of the bag, stuffing yourself.
- X all else see: Igor tears into the Ferret Chow bag, eating greedily.
- XIgor is now carrying the bag. He must drop it if he wants to see the messages
- Xagain. If Murf picks up the bag:
- X Murf types: get Ferret Chow
- X Murf sees: It's icky Ferret Chow. It would probably taste gross.
- X all else see: Murf decides Ferret Chow is icky.
- XBecause the bag was locked to Igor, Murf cannot get the bag.
- X
- XIgor wants to build a few rooms. He can only build off of a place where he
- Xcan get a link. He needs to ask around to find one of these if he is just
- Xstarting to build. Murf is going to give Igor a link named 'n;north'. That
- Xmeans that both 'n' and 'north' activate that exit. Igor digs a room, and
- Xlinks the exit to it. He types:
- X @dig Igor's House
- XAt this point, the program will respond "Igor's House created with room number
- Xxxxx". We'll pretend it gave the room number as 1234.
- X @link n;north=1234
- XThe program will respond with "Linked." Now Igor sets a few messages on the
- Xexit. He types:
- X @desc n=North is Igor's House.
- X @succ n=You crawl into Igor's House.
- X @osucc n=crawls into Igor's House.
- XThese messages work just the same way they work on object, like the Ferret Chow.
- XNext, Igor goes in the room, and creates an out exit. Murf has been nice enough
- Xto not only give Igor the n;north exit, but to set his room to L(ink_ok). Murf's
- Xroom number is 623. Igor types 'n' or 'north' to go in the room, then types:
- X @open out;back;s;south=623
- XThe program will respond with "Opened. Trying to link... Linked." Igor now
- Xhas a south exit back to Murf's room. Murf can now set his room to !link_ok,
- Xso no one else can link to it. Igor puts some messages on the south link as
- Xwell. He decides he wants to describe the room, so he types:
- X @desc here=This is Igor's home. It is a small room, lined with paper shreds.
- X Over in the corner is a small hole.
- XNow Igor wants to dig a small room that the hole connects to. He types:
- X @dig Igor's Hidden Room
- XThe program tells him that the room is number 1250. He then types:
- X @open hole=1250
- X @lock hole=me
- X @desc hole=This is a small hole, just the size of Igor.
- X @fail hole=You can't fit.
- X @ofail hole=can't fit through the hole.
- X @succ hole=You slip into the hole.
- X @osucc hole=slips into the hole.
- XThis creates and links the exit called 'hole' to Igor's Hidden Room. He locks
- Xthe exit to him, so only he can go through the exit. When he uses the exit,
- Xthe success and osuccess messages will be displayed. When someone else tries to
- Xuse the exit, the fail and ofail messages will be displayed. Since Igor owned
- Xthe room that he was linking from, he had to use @open to create the link first.
- XHe now types 'hole' to go in the room, and types '@open out=1234' to create
- Xand link an exit called 'out' that leads to his House.
- XIf Igor wants everyone BUT Murf to be able to go 'hole', he types:
- X @lock hole=!*murf
- XThis locks the hole against the player Murf. If he wants a person to be able to
- Xgo through 'hole' only if they have the bag of Ferret Chow, he types:
- X @lock hole=Ferret Chow
- XIf he wants himself to be able to go in the hole, even if he doesn't have the
- XFerret Chow, he types:
- X @lock hole=Ferret Chow | me
- XIf he wants to lock everyone out except for himself and Murf if Murf has the bag
- Xof Ferret Chow, he types:
- X @lock hole=(*murf & Ferret Chow) | me
- XYou can get more and more complicated with locks this way.
- XIgor is done building his home, and wants to set his home to it, so when he
- Xtypes 'home' he will go there instead of Limbo(#0RDLA). He goes in his house,
- Xand types:
- X @link me=here
- XThe program will respond with "Home set." Now Igor can go 'home', and QUIT
- Xand not worry about his inactive body cluttering up the landscape.
- X
- XCreating whole houses and adventures can be easy if you understand the way
- Xthe @ commands work.
- XWhen you build a room, it makes it neater if you have a very thorough
- Xdescription. Every thing listed in the description can be given a bogus
- Xexit (see entry) to detail the place. For example, here is the description
- Xof a room built by Three.
- X
- X Three's flat(#5400)
- X Red wall-to-wall carpeting covers the floor. A cushy brown leather
- X couch sits across from a wide-screen TV with a VCR and video disc
- X player stacked on top. Escher prints hang on the walls, hilited by
- X track lighting. Papers protrude from a roll-top desk to one side,
- X adjoining an imposing stereo whose controls rival those of 747 cockpits.
- X The kitchen lies north, the foyer south, and the bedroom beyond a
- X short passage east.
- X Contents:
- X Flitterby Award for Comprehensive Building
- X
- XNow, you noticed the desk in the room. A 'look desk' will show:
- X Every drawer and cubby is overflowing with papers, envelopes, flyers,
- X leaflets, folders, booklets, binders, quick reference cards, and
- X other paper products. A Compaq luggable sits in a small canyon of
- X paper. Atop the desk stands a framed photo. Under the desk sits a
- X back stool.
- XNow, since this was done with a exit to create a bogus command, you might
- Xtry going through the exit, so you will get the fail message. A 'desk' will
- Xshow:
- X You rummage thru the desk drawers, finding nothing of interest.
- XHere is an examine of the bogus command, to show you how it was done (only
- Xthe owner or a WIZARD can do an examine and get this output):
- X desk(#5395E)
- X Owner: Three Key: Three(#5370PTF)&!Three(#5370PTF) Pennies: 0
- X Every drawer and cubby is overflowing with papers, envelopes, flyers,
- X leaflets, folders, booklets, binders, quick reference cards, and
- X other paper products. A Compaq luggable sits in a small canyon of
- X paper. Atop the desk stands a framed photo. Under the desk sits a
- X back stool.
- X Fail: You rummage thru the desk drawers, finding nothing of interest.
- X Ofail: rummages thru the desk drawers.
- X Destination: Three's flat(#5400R)
- X
- XIn this way, a highly detailed room can be built, and greatly increase the
- Xatmosphere of the place. Take a walk around and look at the place first,
- Xbefore deciding to build. Then sit down and think carefully about what you
- Xwant to build. Careful planning has made several very interesting places.
- X
- END_OF_FILE
- if test 33769 -ne `wc -c <'tiny.docs'`; then
- echo shar: \"'tiny.docs'\" unpacked with wrong size!
- fi
- # end of 'tiny.docs'
- fi
- echo shar: End of archive 6 \(of 10\).
- cp /dev/null ark6isdone
- MISSING=""
- for I in 1 2 3 4 5 6 7 8 9 10 ; do
- if test ! -f ark${I}isdone ; then
- MISSING="${MISSING} ${I}"
- fi
- done
- if test "${MISSING}" = "" ; then
- echo You have unpacked all 10 archives.
- echo ">>> now type 'sh joinspl.sh'"
- rm -f ark[1-9]isdone ark[1-9][0-9]isdone
- else
- echo You still need to unpack the following archives:
- echo " " ${MISSING}
- fi
- ## End of shell archive.
- exit 0
-